import bcrypt from 'bcryptjs'
import jwt from 'jsonwebtoken'
import { pool } from '../config/db.js'

// JWT密钥
const JWT_SECRET = 'ich-heritage-jwt-secret'

// 存储验证码，在实际生产环境中应使用Redis等缓存服务
const captchaStore = new Map()

// 生成验证码
export const generateCaptcha = (req, res) => {
  // 生成4位随机数字
  const captcha = Math.floor(1000 + Math.random() * 9000).toString()
  const captchaId = Date.now().toString() + Math.random().toString().slice(2, 8)

  // 存储验证码，设置5分钟过期
  captchaStore.set(captchaId, {
    code: captcha,
    expires: Date.now() + 5 * 60 * 1000,
  })

  // 定时清理过期验证码
  setTimeout(
    () => {
      captchaStore.delete(captchaId)
    },
    5 * 60 * 1000,
  )

  // 设置CORS头，确保前端可以访问
  res.header('Access-Control-Allow-Origin', '*')
  res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept')

  // 调试日志
  console.log(`生成验证码: ${captcha}, ID: ${captchaId}`)

  res.status(200).json({
    captchaId,
    captcha,
  })
}

// 验证验证码
const verifyCaptcha = (captchaId, inputCaptcha) => {
  if (!captchaId || !inputCaptcha) {
    return false
  }

  const captchaData = captchaStore.get(captchaId)

  // 验证码不存在或已过期
  if (!captchaData || captchaData.expires < Date.now()) {
    return false
  }

  // 验证码不匹配
  if (captchaData.code !== inputCaptcha) {
    return false
  }

  // 验证成功后删除验证码，防止重复使用
  captchaStore.delete(captchaId)
  return true
}

// 用户注册
export const register = async (req, res) => {
  try {
    const { username, password, email } = req.body

    // 验证必填字段
    if (!username || !password || !email) {
      return res.status(400).json({ message: '用户名、密码和邮箱都是必填的' })
    }

    // 检查用户名是否已存在
    const [existingUsers] = await pool.execute('SELECT * FROM users WHERE username = ?', [username])

    if (existingUsers.length > 0) {
      return res.status(400).json({ message: '用户名已存在' })
    }

    // 密码加密
    const salt = await bcrypt.genSalt(10)
    const hashedPassword = await bcrypt.hash(password, salt)

    // 将用户信息保存到数据库
    const [result] = await pool.execute(
      'INSERT INTO users (username, password, email) VALUES (?, ?, ?)',
      [username, hashedPassword, email],
    )

    // 生成JWT令牌
    const token = jwt.sign({ id: result.insertId, username }, JWT_SECRET, { expiresIn: '24h' })

    res.status(201).json({
      message: '注册成功',
      token,
      user: {
        id: result.insertId,
        username,
        email,
      },
    })
  } catch (error) {
    console.error('注册失败:', error)
    res.status(500).json({ message: '注册失败' })
  }
}

// 用户登录
export const login = async (req, res) => {
  try {
    const { username, password, captchaId, captcha } = req.body

    // 验证必填字段
    if (!username || !password) {
      return res.status(400).json({ message: '用户名和密码都是必填的' })
    }

    // 验证验证码
    if (!captchaId || !captcha) {
      return res.status(400).json({ message: '验证码是必填的' })
    }

    if (!verifyCaptcha(captchaId, captcha)) {
      return res.status(400).json({ message: '验证码错误或已过期' })
    }

    // 查询用户
    const [users] = await pool.execute('SELECT * FROM users WHERE username = ?', [username])

    if (users.length === 0) {
      return res.status(401).json({ message: '用户名或密码错误' })
    }

    const user = users[0]

    // 验证密码
    const isMatch = await bcrypt.compare(password, user.password)
    if (!isMatch) {
      return res.status(401).json({ message: '用户名或密码错误' })
    }

    // 生成JWT令牌
    const token = jwt.sign({ id: user.id, username: user.username }, JWT_SECRET, {
      expiresIn: '24h',
    })

    res.status(200).json({
      message: '登录成功',
      token,
      user: {
        id: user.id,
        username: user.username,
        email: user.email,
      },
    })
  } catch (error) {
    console.error('登录失败:', error)
    res.status(500).json({ message: '登录失败' })
  }
}

// 验证用户身份中间件
export const authenticate = async (req, res, next) => {
  try {
    // 从请求头中获取token
    const token = req.headers.authorization?.split(' ')[1]

    if (!token) {
      return res.status(401).json({ message: '未授权，请先登录' })
    }

    // 验证token
    const decoded = jwt.verify(token, JWT_SECRET)

    // 查询用户信息
    const [users] = await pool.execute('SELECT id, username, email FROM users WHERE id = ?', [
      decoded.id,
    ])

    if (users.length === 0) {
      return res.status(401).json({ message: '用户不存在' })
    }

    // 将用户信息添加到请求对象
    req.user = users[0]
    next()
  } catch (error) {
    console.error('认证失败:', error)
    res.status(401).json({ message: '未授权，请先登录' })
  }
}

// 获取当前用户信息
export const getCurrentUser = async (req, res) => {
  res.status(200).json({ user: req.user })
}
